#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include "logger.h"
#include "gbkuni30.h"
#include "mp3-parse-id3v2.h"

#define _pack __attribute__((packed))

// 最大UTF-8缓冲区大小
#define MAX_UTF_8_SIZE 1024
// 最大文本字段长度
#define MAX_TEXT_LENGTH 256

/**
 * @brief 文本编码类型枚举
 */
typedef enum encoding {
    ISO_8859_1 = 0,  // ISO-8859-1 (Latin-1)编码
    UTF_16 = 1,      // UTF-16编码，带BOM
    UTF_16BE = 2,    // UTF-16BE编码，不带BOM
    UTF_8 = 3,       // UTF-8编码
} encoding_t;

/**
 * @brief ID3v2版本枚举
 */
typedef enum id3v2_version {
    ID3V2_2 = 2,  // ID3v2.2
    ID3V2_3 = 3,  // ID3v2.3
    ID3V2_4 = 4,  // ID3v2.4
} id3v2_version_t;

/**
 * @brief 字节序枚举
 */
typedef enum byte_order {
    ID3_BIG_ENDIAN = 0,     // 大端字节序
    ID3_LITTLE_ENDIAN = 1,  // 小端字节序
} byte_order_t;

/**
 * @brief ID3v2标签头部结构 (10字节)
 */
typedef struct id3v2_header {
    char id[3];           // ID3标识符，值为"ID3"
    uint8_t major_version; // 主版本号
    uint8_t minor_version; // 副版本号
    uint8_t flags;         // 标志位
    uint32_t size;         // 标签大小（不包括头部）
} _pack id3v2_header_t;

/**
 * @brief ID3v2帧头部结构 (10字节)
 */
typedef struct id3v2_frame_header {
    char frame_id[4];    // 帧标识符 (如"TIT2", "TPE1"等)
    uint32_t frame_size; // 帧内容大小
    uint16_t flags;      // 帧标志位
}  _pack  id3v2_frame_header_t;

/**
 * @brief ID3v2文本帧结构
 */
typedef struct id3v3_text_frame {
    char encoding;   // 文本编码方式
    char *text;      // 文本内容（不定长）
} _pack id3v3_text_frame_t;

/**
 * @brief ID3v2注释帧结构
 */
typedef struct id3v3_comment_frame {
    char language[3];  // 语言代码（3字节）
    uint8_t text[0];   // 文本内容（不定长，包括短描述和注释内容）
} _pack id3v3_comment_frame_t;

/**
 * @brief 安全地将字符串复制到目标缓冲区，确保null终止
 * @param dest 目标缓冲区
 * @param src 源字符串
 * @param dest_size 目标缓冲区大小
 * @return 复制的字符数(不包括终止符)
 */
static size_t safe_strncpy(char *dest, const char *src, size_t dest_size) {
    if (!dest || !src || dest_size == 0) return 0;
    
    size_t i;
    for (i = 0; i < dest_size - 1 && src[i] != '\0'; i++) {
        dest[i] = src[i];
    }
    dest[i] = '\0';
    return i;
}

/**
 * @brief 将Unicode码点转换为UTF-8编码
 * @param cp Unicode码点
 * @param buf 输出缓冲区
 * @return 生成的UTF-8字节数，出错时返回-1
 */
static int unicode_to_utf8(uint32_t cp, uint8_t *buf) {
    if (!buf) return -1;
    
    if (cp <= 0x7F) {  // 0xxxxxxx (ASCII范围)
        // 1字节UTF-8
        buf[0] = (uint8_t)cp;
        return 1;
    } else if (cp <= 0x7FF) { // 110xxxxx 10xxxxxx
        // 2字节UTF-8
        buf[0] = 0xC0 | ((cp >> 6) & 0x1F);  // 高5位
        buf[1] = 0x80 | (cp & 0x3F);         // 低6位
        return 2;
    } else if (cp <= 0xFFFF) {  // 1110xxxx 10xxxxxx 10xxxxxx
        // 3字节UTF-8
        buf[0] = 0xE0 | ((cp >> 12) & 0x0F); // 高4位
        buf[1] = 0x80 | ((cp >> 6) & 0x3F);  // 中间6位
        buf[2] = 0x80 | (cp & 0x3F);         // 低6位
        return 3;
    } else if (cp <= 0x10FFFF) { // 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
        // 4字节UTF-8
        buf[0] = 0xF0 | ((cp >> 18) & 0x07); // 高3位
        buf[1] = 0x80 | ((cp >> 12) & 0x3F); // 次高6位
        buf[2] = 0x80 | ((cp >> 6) & 0x3F);  // 次低6位
        buf[3] = 0x80 | (cp & 0x3F);         // 低6位
        return 4;
    } else {
        // 无效Unicode码点
        return -1;
    }
}

/**
 * @brief 检测字符串是否为GBK编码
 * @param data 要检测的数据
 * @param len 数据长度
 * @return GBK编码的置信度(0-100)
 */
static int detect_gbk_confidence(const uint8_t *data, size_t len) {
    if (!data || len == 0) return 0;
    
    size_t i = 0;
    size_t valid_chars = 0;
    size_t total_chars = 0;
    
    while (i < len) {
        uint8_t b1 = data[i];
        // ASCII范围(与GBK兼容)
        if (b1 <= 0x7F) {
            i++;
            total_chars++;
            continue;
        }
        
        // 检测可能的GBK双字节字符
        if (b1 >= 0x81 && b1 <= 0xFE) { // 第一个字节在GBK范围内
            if (i + 1 < len) {
                uint8_t b2 = data[i + 1]; 
                if ((b1 >= 0xB0 && b1 <= 0xF7 && b2 >= 0xA1 && b2 <= 0xFE) || // GB2312区域
                    (b1 >= 0x81 && b1 <= 0xA0) ||                              // GBK扩展区1
                    (b1 >= 0xAA && b1 <= 0xFE)) {                              // GBK扩展区2
                    valid_chars++;
                }
                i += 2;
                total_chars++;
            } else {
                i++;
                total_chars++;
            }
        } else {
            i++;
            total_chars++;
        }
    }
    
    if (total_chars == 0) return 0;
    return (int)(valid_chars * 100 / total_chars);
}

/**
 * @brief 打印数据的十六进制表示
 * @param data 要打印的数据
 * @param len 数据长度
 */
static void print_hex_data(const uint8_t *data, size_t len) {
    for (size_t i = 0; i < len; i++) {
        printf("%02X ", data[i]);
    }
}

/**
 * @brief 将GBK编码转换为UTF-8编码
 * @param input GBK编码的输入
 * @param input_len 输入长度
 * @param output UTF-8输出缓冲区
 * @param output_len 输出缓冲区大小
 * @return 生成的UTF-8字节数
 */
static size_t convert_gbk_to_utf8(const uint8_t *input, size_t input_len, uint8_t *output, size_t output_len) {
    if (!input || !output || input_len == 0 || output_len <= 1) {
        if (output && output_len > 0) output[0] = '\0';
        return 0;
    }
    
    size_t output_index = 0; // 输出缓冲区索引
    size_t input_index = 0;  // 输入缓冲区索引
    
    while (input_index < input_len) {
        // 读取GBK码元
        uint16_t code_unit = input[input_index];
        if(code_unit >= 0x81) { // 可能是GBK双字节字符
            if (input_index + 1 >= input_len) break;
            code_unit = (code_unit << 8) | input[input_index + 1];
            input_index += 2;
        } else {
            input_index++; // ASCII字符，单字节
        }

        // 转换成Unicode
        uint32_t unicode_cp = gbk_2_uni_tab[code_unit];

        // 转换为UTF-8
        uint8_t utf8_buf[4];
        int utf8_len = unicode_to_utf8(unicode_cp, utf8_buf);
        if (utf8_len < 0) continue;

        // 检查输出缓冲区空间
        if (output_index + utf8_len >= output_len) break;

        // 复制到输出缓冲区
        for (int j = 0; j < utf8_len; j++) {
            output[output_index++] = utf8_buf[j];
        }
    }
    
    // 确保字符串以null结尾
    output[output_index] = '\0';
    return output_index;
}

/**
 * @brief 将ISO-8859-1编码转换为UTF-8编码(考虑GBK编码可能性)
 * @param input ISO-8859-1编码的输入
 * @param input_len 输入长度
 * @param output UTF-8输出缓冲区
 * @param output_len 输出缓冲区大小
 * @return 生成的UTF-8字节数
 */
static size_t convert_iso_8859_1_to_utf8(const uint8_t *input, size_t input_len, uint8_t *output, size_t output_len) {
    if (!input || !output || input_len == 0 || output_len <= 1) {
        if (output && output_len > 0) output[0] = '\0';
        return 0;
    }
    
    // GBK编码检测 - 中文MP3文件常错误地使用ISO-8859-1标记GBK编码
    int gbk_confidence = detect_gbk_confidence(input, input_len);
    if(gbk_confidence >= 0) { // 如果有较高可能是GBK编码, 则尝试转换
        //printf("[GBK]");
        return convert_gbk_to_utf8(input, input_len, output, output_len);
    }
    
    // 正常的ISO-8859-1到UTF-8转换
    size_t output_index = 0; // 输出缓冲区索引
    size_t input_index = 0;  // 输入缓冲区索引
    
    while (input_index < input_len) {
        // 读取ISO-8859-1码元
        uint8_t code_unit = input[input_index++];
        uint32_t unicode_cp = code_unit; // ISO-8859-1直接映射到Unicode的前256个码点
        
        // 转换为UTF-8
        uint8_t utf8_buf[4];
        int utf8_len = unicode_to_utf8(unicode_cp, utf8_buf);
        if (utf8_len < 0) continue;
        
        // 检查输出缓冲区空间
        if (output_index + utf8_len >= output_len) break;
        
        // 复制到输出缓冲区
        for (int j = 0; j < utf8_len; j++) {
            output[output_index++] = utf8_buf[j];
        }
    }
    
    // 确保字符串以null结尾
    output[output_index] = '\0';
    return output_index;
}

/**
 * @brief 将UTF-16编码转换为UTF-8编码
 * @param input UTF-16编码的输入
 * @param input_len 输入长度
 * @param byte_order 字节序(大端/小端)
 * @param output UTF-8输出缓冲区
 * @param output_len 输出缓冲区大小
 * @return 生成的UTF-8字节数
 */
static size_t convert_utf16_to_utf8(const uint8_t *input, size_t input_len, byte_order_t byte_order, uint8_t *output, size_t output_len) {
    if (!input || !output || input_len < 2 || output_len <= 1) {
        if (output && output_len > 0) output[0] = '\0';
        return 0;
    }
    
    size_t output_index = 0; // 输出缓冲区索引
    size_t input_index = 0;  // 输入缓冲区索引

    while (input_index < input_len) {
        // 检查剩余字节是否足够读取一个UTF-16码元
        if (input_index + 1 >= input_len) break;
        
        // 根据字节序读取UTF-16码元
        uint16_t code_unit;
        if(byte_order == ID3_BIG_ENDIAN) {
            code_unit = (input[input_index] << 8) | input[input_index + 1];
        } else {
            code_unit = (input[input_index + 1] << 8) | input[input_index];
        }
        input_index += 2;

        uint32_t unicode_cp = 0; // Unicode码点
        bool valid = true;

        // 处理UTF-16代理对
        if (code_unit >= 0xD800 && code_unit <= 0xDBFF) { // 高代理项
            // 需要读取低代理项
            if (input_index + 1 >= input_len) {
                valid = false; // 不完整的代理对
            } else {
                // 读取低代理项
                uint16_t low_surrogate;
                if (byte_order == ID3_BIG_ENDIAN) {
                    low_surrogate = (input[input_index] << 8) | input[input_index + 1];
                } else {
                    low_surrogate = (input[input_index + 1] << 8) | input[input_index];
                }
                input_index += 2;
                
                // 检查低代理项范围
                if (low_surrogate < 0xDC00 || low_surrogate > 0xDFFF) {
                    valid = false; // 无效的低代理项
                } else {
                    // 组合代理对计算码点
                    unicode_cp = 0x10000 + ((code_unit - 0xD800) << 10) + (low_surrogate - 0xDC00);
                }
            }
        } else if (code_unit >= 0xDC00 && code_unit <= 0xDFFF) {
            // 孤立的低代理项，无效
            valid = false;
        } else {
            // 基本多语言平面字符，直接映射
            unicode_cp = code_unit;
        }

        if (!valid) continue; // 跳过无效码点

        // 转换为UTF-8
        uint8_t utf8_buf[4];
        int utf8_len = unicode_to_utf8(unicode_cp, utf8_buf);
        if (utf8_len < 0) continue;

        // 检查输出缓冲区空间
        if (output_index + utf8_len >= output_len) break;

        // 复制到输出缓冲区
        for (int j = 0; j < utf8_len; j++) {
            output[output_index++] = utf8_buf[j];
        }
    }
    
    // 确保字符串以null结尾
    output[output_index] = '\0';
    return output_index;
}

/**
 * @brief 将任意编码的内容转换为UTF-8
 * @param data 输入数据
 * @param data_len 输入数据长度
 * @param utf8_data UTF-8输出缓冲区
 * @param utf8_size 输出缓冲区大小
 * @param encoding 输入数据的编码类型
 * @return 生成的UTF-8字节数
 */
static size_t convert_to_utf8(const uint8_t *data, size_t data_len, uint8_t *utf8_data, size_t utf8_size, encoding_t encoding) {
    if (!data || !utf8_data || data_len == 0 || utf8_size <= 1) {
        if (utf8_data && utf8_size > 0) utf8_data[0] = '\0';
        return 0;
    }
    
    size_t result = 0;
    
    if(encoding == ISO_8859_1) {
        result = convert_iso_8859_1_to_utf8(data, data_len, utf8_data, utf8_size);
    } else if(encoding == UTF_16) { // UTF-16 with BOM
        // 检测BOM确定字节序
        byte_order_t byte_order = (data[0] == 0xFF && data[1] == 0xFE) ? ID3_LITTLE_ENDIAN : ID3_BIG_ENDIAN;
        // 跳过BOM(2字节)
        result = convert_utf16_to_utf8(data + 2, data_len - 2, byte_order, utf8_data, utf8_size);
    } else if(encoding == UTF_16BE) { // UTF-16BE without BOM
        result = convert_utf16_to_utf8(data, data_len, ID3_BIG_ENDIAN, utf8_data, utf8_size);
    } else if(encoding == UTF_8) { // 已经是UTF-8编码
        size_t len = (data_len >= utf8_size - 1) ? utf8_size - 1 : data_len;
        memcpy(utf8_data, data, len);
        utf8_data[len] = '\0';
        result = len;
    } else {
        // 未知编码
        printf("[未知编码:0x%x]", encoding); 
        utf8_data[0] = '\0';
        result = 0;
    }
    
    return result;
}

/**
 * @brief 处理单个ID3v2标签帧并提取重要信息
 * @param frame_id 帧ID
 * @param data 帧数据（完整帧内容）
 * @param data_len 数据长度
 * @param id3v2_info 用于存储提取信息的结构体
 * @param show_info 是否显示解析信息
 */
static void process_id3v2_frame(const char *frame_id, const uint8_t *data, size_t data_len, id3v2_important_info_t *id3v2_info, bool show_info) {
    if (!frame_id || !data || data_len == 0) return;
    
    const char *label;
    uint8_t utf8_data[MAX_UTF_8_SIZE] = {0};
    
    // 确定帧类型标签
    if (strcmp(frame_id, "TIT2") == 0) {label = "标题";}
    else if (strcmp(frame_id, "TPE1") == 0) {label = "艺术家";}
    else if (strcmp(frame_id, "TALB") == 0) {label = "专辑";}
    else if (strcmp(frame_id, "TYER") == 0) {label = "发行年份";}
    else if (strcmp(frame_id, "TRCK") == 0) {label = "轨道编号";}
    else if (strcmp(frame_id, "APIC") == 0) {label = "图片帧";}
    else if (strcmp(frame_id, "COMM") == 0) {label = "注释";}
    else if (strcmp(frame_id, "PRIV") == 0) {label = "私有帧";}
    else if (strcmp(frame_id, "WCOM") == 0) {label = "商业信息URL";}
    else if (strcmp(frame_id, "WORS") == 0) {label = "电台网站URL";}
    else if (strcmp(frame_id, "WOAR") == 0) {label = "艺术家网站URL";}
    else if (strcmp(frame_id, "WOAS") == 0) {label = "音频源网站URL";}
    else {label = frame_id;}
    
    // 处理URL帧（以W开头的帧）
    if (frame_id[0] == 'W' && frame_id[1] != 0) {
        // URL帧没有编码字节，直接是ASCII/ISO-8859-1编码的URL
        if (show_info) printf("【%s:", label);
        // URL通常是ISO-8859-1编码的
        convert_iso_8859_1_to_utf8(data, data_len, utf8_data, MAX_UTF_8_SIZE);
        if (show_info) printf("%s】", utf8_data);
    }
    // 特殊处理COMM帧
    else if (strcmp(frame_id, "COMM") == 0) {
        if (data_len < 4) {  // 至少应有1字节编码+3字节语言代码
            if (show_info) printf("【%s:无效数据】", label);
            return;
        }
        
        encoding_t encoding = data[0];
        char desc[MAX_TEXT_LENGTH] = {0};      // 描述
        char comment[MAX_TEXT_LENGTH] = {0};   // 评论

        id3v3_comment_frame_t *comment_frame = (id3v3_comment_frame_t *)(data + 1);
        if (show_info) printf("【%s:", label);
        if (show_info) printf("语言:%.3s ", comment_frame->language);
        
        // 提取描述部分
        size_t text_offset = 0;
        size_t desc_len = strlen((const char*)comment_frame->text);
        convert_to_utf8(comment_frame->text, desc_len, (uint8_t*)desc, MAX_TEXT_LENGTH, encoding);
        if (show_info) printf("描述:%s ", desc);
        
        // 跳过描述和终止符，寻找评论文本
        text_offset = desc_len;
        while(text_offset < data_len - 4 && comment_frame->text[text_offset] == 0) {
            text_offset++;
        }
        
        // 提取评论部分
        if (text_offset < data_len - 4) {
            size_t comment_len = data_len - 4 - text_offset;
            convert_to_utf8(comment_frame->text + text_offset, comment_len, (uint8_t*)comment, MAX_TEXT_LENGTH, encoding);
            if (show_info) printf("评论:%s】", comment);
            
            // 保存评论到信息结构体
            if (id3v2_info) {
                strncpy(id3v2_info->comm, comment, MAX_TEXT_LENGTH - 1);
                id3v2_info->comm[MAX_TEXT_LENGTH - 1] = '\0';
            }
        } else {
            if (show_info) printf("评论:(空)】");
        }
    } 
    // 特殊处理PRIV帧
    else if (strcmp(frame_id, "PRIV") == 0) {
        // PRIV帧格式：所有者标识符（null终止字符串）+ 二进制数据
        // PRIV帧没有编码类型字节
        
        char owner[MAX_TEXT_LENGTH] = {0};

        // 找到所有者ID结束位置（null结束符）
        size_t owner_len = 0;
        while (owner_len < data_len && data[owner_len] != 0) {
            owner_len++;
        }
        
        // 提取所有者ID
        convert_iso_8859_1_to_utf8(data, owner_len, (uint8_t*)owner, MAX_TEXT_LENGTH);
        
        // 计算和显示二进制数据
        size_t data_offset = owner_len + 1;  // +1跳过null终止符
        
        if (show_info) printf("【%s:{%s:", label, owner);
        
        if (data_offset < data_len) {
            size_t binary_len = data_len - data_offset;
            const uint8_t *binary_data = data + data_offset;
            
            // 根据owner类型选择不同的显示方式
            if (strcmp(owner, "PeakValue") == 0 || strcmp(owner, "AverageLevel") == 0) {
                // 将二进制数据解析为无符号整数（确保为正数）
                uint32_t value = 0;
                if (binary_len >= 4) {
                    // 假设值是4字节整数，小端字节序
                    value = binary_data[0] | (binary_data[1] << 8) | 
                            (binary_data[2] << 16) | (binary_data[3] << 24);
                } else if (binary_len >= 2) {
                    // 假设值是2字节整数，小端字节序
                    value = binary_data[0] | (binary_data[1] << 8);
                } else if (binary_len >= 1) {
                    // 假设值是1字节整数
                    value = binary_data[0];
                }
                if (show_info) printf("%u", value); // 使用%u来确保显示为无符号整数
            } else {
                // 其他类型以十六进制显示，前面加0x
                if (show_info) printf("0x");
                if (show_info) {
                    for (size_t i = 0; i < binary_len; i++) {
                        printf("%02X", binary_data[i]);
                    }
                }
            }
        } else {
            if (show_info) printf("(无数据)");
        }
        
        if (show_info) printf("}】");
    } 
    // 处理一般文本帧
    else if (frame_id[0] == 'T' && frame_id[1] != 0) {
        // 文本帧第一个字节是编码类型
        if (data_len < 1) {
            if (show_info) printf("【%s:无效数据】", label);
            return;
        }
        
        encoding_t encoding = data[0];
        if (show_info) printf("【%s:", label);
        size_t text_len = convert_to_utf8(data + 1, data_len - 1, utf8_data, MAX_UTF_8_SIZE, encoding);
        if (show_info) printf("%s】", utf8_data);
        
        // 保存重要信息到结构体
        if (id3v2_info) {
            if (strcmp(frame_id, "TIT2") == 0) {
                safe_strncpy(id3v2_info->title, (const char*)utf8_data, MAX_TEXT_LENGTH);
            } else if (strcmp(frame_id, "TPE1") == 0) {
                safe_strncpy(id3v2_info->artist, (const char*)utf8_data, MAX_TEXT_LENGTH);
            } else if (strcmp(frame_id, "TALB") == 0) {
                safe_strncpy(id3v2_info->album, (const char*)utf8_data, MAX_TEXT_LENGTH);
            } else if (strcmp(frame_id, "TRCK") == 0) {
                safe_strncpy(id3v2_info->track, (const char*)utf8_data, MAX_TEXT_LENGTH);
            } else if (strcmp(frame_id, "TYER") == 0) {
                safe_strncpy(id3v2_info->year, (const char*)utf8_data, MAX_TEXT_LENGTH);
            }
        }
    }
    // 其他未特殊处理的帧类型
    else {
        if (show_info) printf("【%s:未处理类型(%zu字节)】", label, data_len);
    }
}

/**
 * @brief 解析MP3文件中的ID3v2标签
 * @param file 已打开的MP3文件指针
 * @param id3v2_info 用于存储解析出的元数据的结构体指针
 * @param show_info 是否显示解析信息，true表示显示，false表示静默模式
 * @return 返回ID3v2标签的总大小(字节)，包括头部
 */
size_t parse_id3v2(FILE *file, id3v2_important_info_t *id3v2_info, bool show_info) {
    if (!file) {
        if (show_info) printf("错误: 无效的文件指针\n");
        return 0;
    }
    
    // 保存原始文件位置，以便在出错时恢复
    long original_pos = ftell(file);
    if (original_pos < 0) {
        if (show_info) printf("错误: 无法获取文件位置\n");
        return 0;
    }
    
    unsigned char header[10];
    
    // 初始化结构体(如果提供)
    if (id3v2_info) {
        memset(id3v2_info, 0, sizeof(id3v2_important_info_t));
    }
    
    // 读取ID3v2头部
    if (fread(header, 1, 10, file) != 10) {
        if (show_info) printf("无法读取 ID3v2 头部\n");
        fseek(file, original_pos, SEEK_SET);  // 恢复文件位置
        return 0;
    }

    // 检查ID3标识符
    if (memcmp(header, "ID3", 3) != 0) {
        if (show_info) printf("没有ID3v2信息\n");
        fseek(file, original_pos, SEEK_SET);  // 恢复文件位置
        return 0;
    }

    int major_version = header[3];
    // ID3v2 大小（同步安全整数，去掉高位标志）
    size_t size = ((header[6] & 0x7F) << 21) | ((header[7] & 0x7F) << 14) |
                  ((header[8] & 0x7F) << 7) | (header[9] & 0x7F);

    if (show_info) printf("ID3v2.%d(%zu字节):", major_version, size);
    
    // 检查版本兼容性
    if(major_version <= 2 || major_version > 4) {
        if (show_info) printf("不支持的 ID3v2 版本\n");
        return 10; // 只返回头部长度
    }
    
    // 防止过大的标签尺寸导致内存问题
    if (size > 10 * 1024 * 1024) { // 10MB上限
        if (show_info) printf("ID3v2标签过大 (%zu 字节), 可能无效\n", size);
        return 10;
    }

    // 分配内存并读取标签内容
    uint8_t *buffer = malloc(size);
    if (!buffer) {
        if (show_info) printf("内存分配失败\n");
        return 10;
    }
    
    if (fread(buffer, 1, size, file) != size) {
        if (show_info) printf("无法读取完整的ID3v2数据\n");
        free(buffer);
        fseek(file, original_pos + 10, SEEK_SET); // 恢复到头部之后
        return 10;
    }

    // 解析标签中的帧
    size_t pos = 0;
    bool has_parsed_frames = false;
    
    while (pos + 10 <= size) { // 确保至少有足够空间读取帧头
        // 读取帧ID
        char frame_id[5] = {0};
        memcpy(frame_id, buffer + pos, 4);
        pos += 4;

        // 检查是否遇到填充或结束
        if (frame_id[0] == 0) {
            //if (show_info) printf(" [填充区域]");
            break;
        }
        
        has_parsed_frames = true;

        // 读取帧大小
        int frame_size;
        if (major_version == 4) {
            // ID3v2.4使用同步安全整数表示帧大小
            frame_size = ((buffer[pos] & 0x7F) << 21) | 
                         ((buffer[pos + 1] & 0x7F) << 14) |
                         ((buffer[pos + 2] & 0x7F) << 7) | 
                         (buffer[pos + 3] & 0x7F);
        } else {
            // ID3v2.3及以下版本使用普通整数
            frame_size = (buffer[pos] << 24) | (buffer[pos + 1] << 16) |
                         (buffer[pos + 2] << 8) | buffer[pos + 3];
        }
        pos += 4;

        // 帧大小有效性检查
        if (frame_size < 0 || frame_size > 10 * 1024 * 1024) { // 10MB上限
            if (show_info) printf(" [无效帧大小 %d]", frame_size);
            break;
        }

        // 处理标志位
        uint16_t flags = (buffer[pos] << 8) | buffer[pos + 1];
        pos += 2;

        // 检查剩余空间是否足够处理帧内容
        if (pos + frame_size > size) {
            if (show_info) printf(" [帧超出标签边界]");
            break;
        }

        // 处理ID3v2.4特有的帧状态标志
        if (major_version == 4) {
            // 解析标志位
            bool tag_alter_preserve = (flags & 0x4000) != 0;
            bool file_alter_preserve = (flags & 0x2000) != 0;
            bool read_only = (flags & 0x1000) != 0;
            
            // 格式标志
            bool grouping_identity = (flags & 0x0040) != 0;
            bool compression = (flags & 0x0008) != 0;
            bool encryption = (flags & 0x0004) != 0;
            bool unsynchronisation = (flags & 0x0002) != 0;
            bool data_length_indicator = (flags & 0x0001) != 0;
            
            // 不支持压缩或加密
            if (compression || encryption) {
                if (show_info) printf(" [跳过压缩/加密帧 %s]", frame_id);
                pos += frame_size;
                continue;
            }
            
            // 如果有数据长度指示器，跳过4字节
            if (data_length_indicator) {
                if (frame_size < 4) {
                    if (show_info) printf(" [无效的数据长度指示器]");
                    break;
                }
                pos += 4;
                frame_size -= 4;
            }
        }

        // 帧内容必须至少包含一个字节
        if (frame_size <= 0) {
            pos += frame_size;
            continue;
        }

        // 获取完整的帧数据
        const uint8_t *frame_data = buffer + pos;

        // 处理特定于ID3v2.4的帧ID映射
        char mapped_frame_id[5] = {0};
        strcpy(mapped_frame_id, frame_id);
        
        // v2.4中TDRC替代了v2.3中的TYER
        if (major_version == 4 && strcmp(frame_id, "TDRC") == 0) {
            strcpy(mapped_frame_id, "TYER");
        }

        // 传递完整的帧数据，让process_id3v2_frame根据帧类型决定如何处理
        process_id3v2_frame(mapped_frame_id, frame_data, frame_size, id3v2_info, show_info);

        pos += frame_size;
    }
    
    // 如果没有解析到任何有效帧，提示用户
    if (!has_parsed_frames && show_info) {
        printf(" [未找到有效帧]");
    }
    
    if (show_info) printf("\n");

    free(buffer);
    return size + 10; // 返回总长度（头部 10 字节 + 数据大小）
}